const Controller = require('egg').Controller;

class UploadController extends Controller {
    // 上传帖子图片
    async uploadPostImage() {
        const { ctx, service } = this;

        try {
            console.log('收到帖子图片上传请求');

            // 验证token
            const token = ctx.request.header.token;
            if (!token) {
                throw new Error('未提供token');
            }

            const decode = ctx.app.jwt.verify(token, ctx.app.config.jwt.secret);
            const userId = decode.user_id;

            console.log('用户ID:', userId);

            // 获取上传的文件
            const file = ctx.request.files[0];
            if (!file) {
                throw new Error('请选择要上传的图片');
            }

            console.log('上传文件信息:', {
                filename: file.filename,
                filepath: file.filepath,
                mimeType: file.mimeType,
                size: file.size
            });

            // 验证文件类型
            const allowedTypes = ['image/jpeg', 'image/png', 'image/gif', 'image/webp'];
            if (!allowedTypes.includes(file.mimeType)) {
                throw new Error('只支持 jpg、png、gif、webp 格式的图片');
            }

            // 验证文件大小（限制为5MB）
            const maxSize = 5 * 1024 * 1024;
            if (file.size > maxSize) {
                throw new Error('图片大小不能超过5MB');
            }

            // 上传帖子图片
            const imageUrl = await service.upload.uploadPostImage(file, userId);
            console.log('新图片URL:', imageUrl);

            ctx.body = {
                code: 0,
                data: {
                    url: imageUrl
                },
                msg: '图片上传成功'
            };

            console.log('帖子图片上传完成');

        } catch (error) {
            console.error('帖子图片上传错误:', error);

            // 清理临时文件
            if (ctx.request.files) {
                ctx.cleanupRequestFiles();
            }

            if (error.errors) {
                ctx.body = {
                    code: 1,
                    data: null,
                    msg: `参数错误: ${error.errors[0].field} ${error.errors[0].message}`
                };
                return;
            }

            ctx.body = {
                code: 1,
                data: null,
                msg: error.message || '图片上传失败'
            };
        }
    }

    // 上传圈子帖子图片
    async uploadCirclePostImage() {
        const { ctx, service } = this;

        try {
            console.log('收到圈子帖子图片上传请求');

            // 验证token
            const token = ctx.request.header.token;
            if (!token) {
                throw new Error('未提供token');
            }

            const decode = ctx.app.jwt.verify(token, ctx.app.config.jwt.secret);
            const userId = decode.user_id;

            // 获取圈子ID
            const { circle_id } = ctx.request.body;
            if (!circle_id) {
                throw new Error('圈子ID不能为空');
            }

            console.log('用户ID:', userId, '圈子ID:', circle_id);

            // 获取上传的文件
            const file = ctx.request.files[0];
            if (!file) {
                throw new Error('请选择要上传的图片');
            }

            console.log('上传文件信息:', {
                filename: file.filename,
                filepath: file.filepath,
                mimeType: file.mimeType,
                size: file.size
            });

            // 验证文件类型
            const allowedTypes = ['image/jpeg', 'image/png', 'image/gif', 'image/webp'];
            if (!allowedTypes.includes(file.mimeType)) {
                throw new Error('只支持 jpg、png、gif、webp 格式的图片');
            }

            // 验证文件大小（限制为5MB）
            const maxSize = 5 * 1024 * 1024;
            if (file.size > maxSize) {
                throw new Error('图片大小不能超过5MB');
            }

            // 上传圈子帖子图片
            const imageUrl = await service.upload.uploadCirclePostImage(file, userId, circle_id);
            console.log('新图片URL:', imageUrl);

            ctx.body = {
                code: 0,
                data: {
                    url: imageUrl
                },
                msg: '图片上传成功'
            };

            console.log('圈子帖子图片上传完成');

        } catch (error) {
            console.error('圈子帖子图片上传错误:', error);

            // 清理临时文件
            if (ctx.request.files) {
                ctx.cleanupRequestFiles();
            }

            if (error.errors) {
                ctx.body = {
                    code: 1,
                    data: null,
                    msg: `参数错误: ${error.errors[0].field} ${error.errors[0].message}`
                };
                return;
            }

            ctx.body = {
                code: 1,
                data: null,
                msg: error.message || '图片上传失败'
            };
        }
    }

    // 上传单张商品图片
    async uploadGoodImage() {
        const { ctx, service } = this;

        try {
            // 验证用户登录
            const token = ctx.request.header.token;
            if (!token) {
                throw new Error('请先登录');
            }

            const decode = ctx.app.jwt.verify(token, ctx.app.config.jwt.secret);
            if (decode.type !== 'user') {
                throw new Error('无权限操作');
            }

            // 获取上传的文件
            const file = ctx.request.files[0];
            if (!file) {
                throw new Error('请选择要上传的图片');
            }

            console.log('收到商品图片上传请求，用户ID:', decode.user_id, '文件名:', file.filename);

            // 调用Service上传图片
            const result = await service.upload.uploadGoodImage(file, decode.user_id);

            ctx.body = {
                code: 0,
                data: result,
                msg: '上传成功'
            };

        } catch (error) {
            console.error('商品图片上传失败:', error);

            ctx.body = {
                code: 1,
                data: null,
                msg: error.message || '上传失败'
            };
        } finally {
            // 确保清理临时文件
            await ctx.cleanupRequestFiles();
        }
    }

    // 上传多张商品图片
    async uploadMultipleGoodImages() {
        const { ctx, service } = this;

        try {
            // 验证用户登录
            const token = ctx.request.header.token;
            if (!token) {
                throw new Error('请先登录');
            }

            const decode = ctx.app.jwt.verify(token, ctx.app.config.jwt.secret);
            if (decode.type !== 'user') {
                throw new Error('无权限操作');
            }

            // 获取上传的文件
            const files = ctx.request.files;
            if (!files || files.length === 0) {
                throw new Error('请选择要上传的图片');
            }

            console.log('收到多张商品图片上传请求，用户ID:', decode.user_id, '文件数量:', files.length);

            // 限制最大上传数量
            const maxFiles = 5;
            if (files.length > maxFiles) {
                throw new Error(`最多只能上传 ${maxFiles} 张图片`);
            }

            // 调用Service上传图片
            const results = await service.upload.uploadMultipleGoodImages(files, decode.user_id);

            // 分离成功和失败的结果
            const successResults = results.filter(r => !r.error);
            const failedResults = results.filter(r => r.error);

            ctx.body = {
                code: 0,
                data: {
                    success: successResults,
                    failed: failedResults
                },
                msg: failedResults.length > 0 ?
                    `成功上传 ${successResults.length} 张，失败 ${failedResults.length} 张` :
                    '全部上传成功'
            };

        } catch (error) {
            console.error('多张商品图片上传失败:', error);

            ctx.body = {
                code: 1,
                data: null,
                msg: error.message || '上传失败'
            };
        } finally {
            // 确保清理临时文件
            await ctx.cleanupRequestFiles();
        }
    }

    // 删除商品图片
    async deleteGoodImage() {
        const { ctx, service } = this;

        try {
            // 验证用户登录
            const token = ctx.request.header.token;
            if (!token) {
                throw new Error('请先登录');
            }

            const decode = ctx.app.jwt.verify(token, ctx.app.config.jwt.secret);
            if (decode.type !== 'user') {
                throw new Error('无权限操作');
            }

            const { imageUrl } = ctx.request.body;
            if (!imageUrl) {
                throw new Error('请提供要删除的图片URL');
            }

            console.log('收到商品图片删除请求，用户ID:', decode.user_id, '图片URL:', imageUrl);

            // 调用Service删除图片
            await service.upload.deleteGoodImage(imageUrl);

            ctx.body = {
                code: 0,
                data: null,
                msg: '删除成功'
            };

        } catch (error) {
            console.error('商品图片删除失败:', error);

            ctx.body = {
                code: 1,
                data: null,
                msg: error.message || '删除失败'
            };
        }
    }

    // 上传轮播图
    async uploadBannerImage() {
        const { ctx, service } = this;

        try {
            console.log('收到轮播图上传请求');

            // 获取上传的文件
            const file = ctx.request.files[0];
            if (!file) {
                throw new Error('请选择要上传的图片');
            }

            console.log('上传文件信息:', {
                filename: file.filename,
                filepath: file.filepath,
                mimeType: file.mimeType,
                size: file.size
            });

            // 验证文件类型
            const allowedTypes = ['image/jpeg', 'image/png', 'image/gif', 'image/webp'];
            if (!allowedTypes.includes(file.mimeType)) {
                throw new Error('只支持 jpg、png、gif、webp 格式的图片');
            }

            // 验证文件大小（限制为5MB）
            const maxSize = 5 * 1024 * 1024;
            if (file.size > maxSize) {
                throw new Error('图片大小不能超过5MB');
            }

            // 使用现有的上传服务，但指定轮播图目录
            const imageUrl = await service.upload.uploadBannerImage(file);
            console.log('轮播图URL:', imageUrl);

            ctx.body = {
                code: 0,
                data: {
                    url: imageUrl
                },
                msg: '轮播图上传成功'
            };

            console.log('轮播图上传完成');

        } catch (error) {
            console.error('轮播图上传错误:', error);

            // 清理临时文件
            if (ctx.request.files) {
                ctx.cleanupRequestFiles();
            }

            if (error.errors) {
                ctx.body = {
                    code: 1,
                    data: null,
                    msg: `参数错误: ${error.errors[0].field} ${error.errors[0].message}`
                };
                return;
            }

            ctx.body = {
                code: 1,
                data: null,
                msg: error.message || '轮播图上传失败'
            };
        }
    }
}

module.exports = UploadController;


